package com.hisense.ovcloud.apicontrol.tool;

import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.JavaType;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;
import com.fasterxml.jackson.databind.module.SimpleModule;
import com.fasterxml.jackson.databind.ser.impl.SimpleFilterProvider;
import com.fasterxml.jackson.databind.type.TypeFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.LinkedHashMap;
import java.util.Map;

public class JacksonUtils {

    private static final Logger logger = LoggerFactory.getLogger(JacksonUtils.class);

    private static final ObjectMapper objectMapper = new ObjectMapper();

    static {
        // 配置：忽略未知属性
        objectMapper.disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES);
        // 允许序列化空对象
        objectMapper.disable(SerializationFeature.FAIL_ON_EMPTY_BEANS);
        // 过滤器配置
        objectMapper.setFilterProvider(new SimpleFilterProvider());
        // 序列化时忽略 null 和空值
        objectMapper.setSerializationInclusion(JsonInclude.Include.NON_EMPTY);

        // **关键配置：强制使用 LinkedHashMap 保留顺序**
        objectMapper.registerModule(new SimpleModule()
                .addAbstractTypeMapping(Map.class, LinkedHashMap.class));

        // 禁用序列化时的按键排序（如果已启用）
        objectMapper.disable(SerializationFeature.ORDER_MAP_ENTRIES_BY_KEYS);
    }

    /**
     * 对象转换为 JSON 字符串
     *
     * @param obj 要转换的对象
     * @param <T> 对象类型
     * @return JSON 字符串或 null
     */
    public static <T> String objectToJson(T obj) {
        if (obj == null) {
            return null;
        }
        try {
            return obj instanceof String ? (String) obj : objectMapper.writeValueAsString(obj);
        } catch (JsonProcessingException e) {
            logger.error("对象转 JSON 异常", e);
            return null;
        }
    }

    /**
     * 对象转换为格式化 JSON 字符串
     *
     * @param obj 要转换的对象
     * @param <T> 对象类型
     * @return 格式化后的 JSON 字符串或 null
     */
    public static <T> String objectToJsonPretty(T obj) {
        if (obj == null) {
            return null;
        }
        try {
            return obj instanceof String ? (String) obj
                    : objectMapper.writerWithDefaultPrettyPrinter().writeValueAsString(obj);
        } catch (JsonProcessingException e) {
            logger.error("对象转 JSON 异常", e);
            return null;
        }
    }

    /**
     * JSON 字符串转换为对象
     *
     * @param src   JSON 字符串
     * @param clazz 目标对象类型
     * @param <T>   泛型类型
     * @return 转换后的对象或 null
     */
    public static <T> T jsonToObject(String src, Class<T> clazz) {
        if (src == null || src.isEmpty() || clazz == null) {
            return null;
        }
        try {
            return clazz.equals(String.class) ? (T) src : objectMapper.readValue(src, clazz);
        } catch (Exception e) {
            logger.error("JSON 转对象异常", e);
            return null;
        }
    }

    /**
     * JSON 字符串转换为泛型对象（如 List<Map<String, Object>）
     *
     * @param src          JSON 字符串
     * @param typeReference 泛型类型引用（如 new TypeReference<List<MyBean>>() {}）
     * @param <T>          泛型类型
     * @return 转换后的对象或 null
     */
    public static <T> T jsonToObject(String src, TypeReference<T> typeReference) {
        if (src == null || src.isEmpty() || typeReference == null) {
            return null;
        }
        try {
            return (T) (typeReference.getType().equals(String.class) ? src
                    : objectMapper.readValue(src, typeReference));
        } catch (Exception e) {
            logger.error("JSON 转对象异常", e);
            return null;
        }
    }

    /**
     * JSON 字符串转换为复杂泛型对象（如 List<MyBean>）
     *
     * @param src           JSON 字符串
     * @param collectionClass 集合类型（如 List.class）
     * @param elementClasses 元素类型（如 MyBean.class）
     * @param <T>           泛型类型
     * @return 转换后的对象或 null
     */
    public static <T> T jsonToObject(String src, Class<?> collectionClass, Class<?>... elementClasses) {
        JavaType javaType = TypeFactory.defaultInstance().constructParametricType(collectionClass, elementClasses);
        try {
            return objectMapper.readValue(src, javaType);
        } catch (Exception e) {
            logger.error("JSON 转对象异常", e);
            return null;
        }
    }

    /**
     * Map 转换为 Java 对象
     *
     * @param map     输入的 Map
     * @param beanClass 目标对象类型
     * @return 转换后的对象或 null
     */
    public static Object mapToObject(Map<String, Object> map, Class<?> beanClass) {
        if (map == null) {
            return null;
        }
        return objectMapper.convertValue(map, beanClass);
    }

    /**
     * Java 对象转换为 Map
     *
     * @param obj 输入对象
     * @return 转换后的 Map 或 null
     */
    public static Map<?, ?> objectToMap(Object obj) {
        if (obj == null) {
            return null;
        }
        return objectMapper.convertValue(obj, Map.class);
    }

    public static void main(String[] args) {
        System.out.println("1");
    }
}